import { requestResponse, requestStream } from '@tau/rsocket';

const base = 'dicts';

// 样板

/**
 * 符合条件的字典条目数
 * @param {{{ keyword: string, from: datetime, to: datetime, page: number, size: number}}} 查询参数，分页参数
 * @returns 符合条件的字典条目数
 */
export function countDict({ keyword, from, to } = {}) {
  return requestResponse({
    route: `${base}.count`,
    args: {
      search: { keyword, from, to },
    },
  });
}

/**
 * 搜索字典列表
 * @param {{{ keyword: string, from: datetime, to: datetime, page: number, size: number}}} 查询参数，分页参数
 * @returns 字典列表
 */
export function searchDict({ keyword, from, to, page = 0, size = PGSIZE, sort } = {}) {
  return requestStream({
    route: `${base}`,
    args: {
      search: { keyword, from, to },
      pg: { page, size, sort: sort && sort.split(',') },
    },
  });
}

/**
 * 获取指定字典
 * @param {string} dictId
 * @returns 返回字典
 */
export function getDict(dictId) {
  return requestResponse({
    route: `${base}.${ROUTE(dictId)}`,
  });
}

/**
 * 添加字典
 * @param {*} dict 待添加的字典
 * @returns 添加后的字典
 */
export function createDict(dict) {
  return requestResponse({
    route: `${base}.create`,
    data: dict,
  });
}

/**
 * 修改字典
 * @param {*} dict 包含修改内容的字典数据
 * @returns 修改后的字典
 */
export function updateDict(dict) {
  // if (!dict?.id) return Promise.reject(new Error('id must not be null.'));
  return requestResponse({
    route: `${base}.replace`,
    data: dict,
  });
}

/**
 * 删除数据字典
 */
export function deleteDict(dictId) {
  return requestResponse({
    route: `${base}.${ROUTE(dictId)}.delete`,
  });
}


// ---------------------------------------
/**
 * 符合条件的字典项条目数
 * @param {{{ keyword: string, from: datetime, to: datetime}}} 查询参数，分页参数
 * @returns 符合条件的字典项条目数
 */
export function countDictItem(dictId, { keyword, from, to } = {}) {
  return requestResponse({
    route: `${base}.${ROUTE(dictId)}.items.count`,
    args: {
      search: { keyword, from, to },
    },
  });
}

/**
 * 搜索字典列表
 * @param {{{ keyword: string, from: datetime, to: datetime, page: number, size: number}}} 查询参数，分页参数
 * @returns 字典列表
 */
export function searchDictItem(dictId, { keyword, from, to, page = 0, size = PGSIZE, sort } = {}) {
  return requestStream({
    route: `${base}.${ROUTE(dictId)}.items`,
    args: {
      search: { keyword, from, to },
      pg: { page, size, sort: sort && sort.split(',') },
    },
  });
}

/**
 * 获取指定字典
 * @param {string} dictId
 * @param {string} itemId
 * @returns 返回字典项
 */
export function getDictItem(dictId, itemId) {
  return requestResponse({
    route: `${base}.${ROUTE(dictId)}.items.${ROUTE(itemId)}`,
  });
}

/**
 * 获取树形字典的顶级节点
 * @param {string} dictId
 * @returns 返回字典项列表
 */
export function getTopItems(dictId) {
  return requestStream({
    route: `${base}.${ROUTE(dictId)}.items.top`,
  });
}

/**
 * 获取树形字典的指定节点下的子节点
 * @param {string} dictId
 * @param {string} itemId
 * @returns 返回字典项列表
 */
export function getChildren(dictId, parentId) {
  return requestStream({
    route: `${base}.${ROUTE(dictId)}.items.${ROUTE(parentId)}`,
  });
}

/**
 * 添加字典项
 * @param {*} dict 待添加的字典项
 * @returns 添加后的字典项
 */
export function createDictItem(dictItem) {
  if (!dictItem?.dictId || !dictItem?.itemId) return Promise.reject(new Error('id must not be null.'));
  return requestResponse({
    route: `${base}.${ROUTE(dictItem.dictId)}.items.create`,
    data: dictItem,
  });
}

/**
 * 修改字典项
 * @param {*} dictItem 包含修改内容的字典项数据
 * @returns updated dictItem
 */
export function updateDictItem(dictItem) {
  if (!dictItem?.dictId || !dictItem?.itemId) return Promise.reject(new Error('id must not be null.'));
  return requestResponse({
    route: `${base}.${ROUTE(dictItem.dictId)}.items.replace`,
    data: dictItem,
  });
}

/**
 * 删除数据字典项
 * @param {string} dictId 字典标识
 * @param {string} itemId 字典项标识
 */
export function deleteDictItem(dictId, itemId) {
  if (!dictId || !itemId) return Promise.reject(new Error('id must not be null.'));
  return requestResponse({
    route: `${base}.${ROUTE(dictId)}.items.${ROUTE(itemId)}.delete`,
  });
}

/**
 * 获取字典项扩展数据
 * @param {string} dictId 字典标识
 * @param {string} itemId 字典项标识
 * @returns 扩展属性列表
 */
export function getExtras(dictId, itemId) {
  if (!dictId || !itemId) return Promise.reject(new Error('id must not be null.'));
  return requestStream({
    route: `${base}.${ROUTE(dictId)}.items.${ROUTE(itemId)}.extras`,
  });
}

